//!Includes

#include "DriverMatrix.h"
#include <ncurses/curses.h>

//!Global Functions


namespace driver
{

/**
 * class Driver
 *
 *
 * Autor:David Bevilaqua
 *
 *
 * DESCRIPTION:
 *
 */

//!Constructors/Destructors

/**
 * Empty Constructor
 */
DriverMatrix::DriverMatrix ( )
{
	initAttributes ();
}

/**
 * Empty Destructor
 */
DriverMatrix::~DriverMatrix ( )
{

}

//!Public Accessor Methods



//!Public Methods


//!Protected Methods



//!Private Methods

float **DriverMatrix::CppCriaMatriz(int NumeroLinhas,int NumeroColunas)
{
	return CriaMatriz( NumeroLinhas, NumeroColunas);
}
float **DriverMatrix::CppApagaMatriz(float **A, int NumeroLinhas, int NumeroColunas)
{
	return ApagaMatriz( A, NumeroLinhas, NumeroColunas);
}
float  *DriverMatrix::CppCriaVetor(int NumeroElementos)
{
	return CriaVetor(NumeroElementos);
}
float  *DriverMatrix::CppApagaVetor(float *A)
{
	return ApagaVetor(A);
}
float **DriverMatrix::CppMultiplicaMatriz(float **A,int LinhasA,int ColunasA,float **B,int LinhasB,int ColunasB)
{
	return MultiplicaMatriz( A, LinhasA, ColunasA, B,LinhasB,ColunasB);
}
float **DriverMatrix::CppMultiplicaVetorDiagonal(float **A,int LinhasA,int ColunasA,float *B,int ElementosB)
{
	return MultiplicaVetorDiagonal( A, LinhasA, ColunasA, B, ElementosB);
}
float  *DriverMatrix::CppMultiplicaVetor(float **A,int LinhasA,int ColunasA,float *B)
{
	return MultiplicaVetor( A, LinhasA, ColunasA, B);
}
float **DriverMatrix::CppMultiplicaConstante(float **A,int LinhasA,int ColunasA,float B)
{
	return MultiplicaConstante( A, LinhasA, ColunasA, B);
}
float  *DriverMatrix::CppMultiplicaConstante(float  *A,int ElementosA,float B)
{
	return MultiplicaConstante( A, ElementosA, B);
}
float **DriverMatrix::CppSomaMatriz(float **A,int LinhasA,int ColunasA,float **B)
{
	return SomaMatriz( A, LinhasA, ColunasA, B);
}
float **DriverMatrix::CppSubtraiMatriz(float **A,int LinhasA,int ColunasA,float **B)
{
	return SubtraiMatriz( A, LinhasA, ColunasA, B);
}
float   DriverMatrix::CppCalculaSomaElementos(float **Matriz,int NumLinhas,int NumColunas)
{
	return CalculaSomaElementos( Matriz, NumLinhas,NumColunas);
}
float   DriverMatrix::CppCalculaSomaElementos(float *Vetor,int NumElementos)
{
	return CalculaSomaElementos( Vetor, NumElementos);
}
float   DriverMatrix::CppCalculaMediaElementos(float **Matriz,int NumLinhas,int NumColunas)
{
	return CalculaMediaElementos( Matriz, NumLinhas, NumColunas);
}
float   DriverMatrix::CppCalculaMediaElementos(float *Vetor,int NumElementos)
{
	return CalculaMediaElementos( Vetor, NumElementos);
}
float   DriverMatrix::CppCalculaMaximoElemento(float **Matriz,int NumLinhas,int NumColunas)
{
	return CalculaMaximoElemento( Matriz, NumLinhas, NumColunas);
}
float   DriverMatrix::CppCalculaMaximoElemento(float *Vetor,int NumElementos)
{
	return CalculaMaximoElemento( Vetor, NumElementos);
}
float   DriverMatrix::CppCalculaMinimoElemento(float **Matriz,int NumLinhas,int NumColunas)
{
	return CalculaMinimoElemento( Matriz, NumLinhas, NumColunas);
}
float   DriverMatrix::CppCalculaMinimoElemento(float *Vetor,int NumElementos)
{
	return CalculaMinimoElemento( Vetor, NumElementos);
}
float   DriverMatrix::CppCalculaVarianciaElementos(float **Matriz,int NumLinhas,int NumColunas)
{
	return CalculaVarianciaElementos( Matriz, NumLinhas, NumColunas);
}

float **DriverMatrix::CppCalculaAdjunta(float **A,int NumLinhas)
{
	return CalculaAdjunta( A, NumLinhas);
}
float **DriverMatrix::CppCalculaCofatores(float **Matriz,int NumLinhas)
{
	return CalculaCofatores( Matriz, NumLinhas);
}
float **DriverMatrix::CppCalculaTransposta(float **A,int LinhasA,int ColunasA)
{
	return CalculaTransposta( A, LinhasA, ColunasA);
}
float   DriverMatrix::CppCalculaDeterminante(float **Matriz,int NumLinhas)
{
	return CalculaDeterminante( Matriz, NumLinhas);
}

float **DriverMatrix::CppCalculaInversa   (float **Matriz,int NumLinhas)
{
	return CalculaInversa   ( Matriz, NumLinhas);
}
float **DriverMatrix::CppCalculaInversaLU (float **Matriz,int NumLinhas)
{
	return CalculaInversaLU ( Matriz, NumLinhas);
}
float **DriverMatrix::CppCalculaInversaSVD(float **Matriz,int NumLinhas)
{
	return CalculaInversaSVD( Matriz, NumLinhas);
}



float **DriverMatrix::CppRemoveColuna(float **Matriz,int NumLinhas, int NumColunas,int ColunaRemovida)
{
	return RemoveColuna( Matriz, NumLinhas,  NumColunas, ColunaRemovida);
}
float **DriverMatrix::CppRemoveLinha(float **Matriz,int NumLinhas, int NumColunas,int LinhaRemovida)
{
	return RemoveLinha( Matriz, NumLinhas,  NumColunas, LinhaRemovida);
}

int     DriverMatrix::CppFatoracaoLU(float **A,int LinhasMatriz,float **Permutacao)
{
	return FatoracaoLU( A, LinhasMatriz, Permutacao);
}
void    DriverMatrix::CppEliminacaoGaussJordan(float **A,float **B,int LinhasMatriz,int ColunasMatriz)
{
	return EliminacaoGaussJordan( A, B, LinhasMatriz, ColunasMatriz);
}
int     DriverMatrix::CppDecomposicaoSVD(float **a, int m, int n, float *w, float **v)
{
	return DecomposicaoSVD( a,  m,  n,  w,  v);
}

float  *DriverMatrix::CppSolucaoSistemaSVD(float **A,int NumLinhasA,int NumColunasA,float *B)
{
	return SolucaoSistemaSVD( A, NumLinhasA, NumColunasA, B);
}
float  *DriverMatrix::CppSolucaoSistemaLU(float **MatrizFatoradaLU,int NumLinhas,float **Permutacao,float *Vetor)
{
	return SolucaoSistemaLU( MatrizFatoradaLU, NumLinhas, Permutacao, Vetor);
}

float  *DriverMatrix::CppCalculaAngulosEulerMatrizRotacao(float **Rw)
{
	return CalculaAngulosEulerMatrizRotacao( Rw);
}

float **DriverMatrix::Cpp_RotX(float Angulo)
{
	return _RotX( Angulo);
}
float **DriverMatrix::Cpp_RotY(float Angulo)
{
	return _RotY( Angulo);
}
float **DriverMatrix::Cpp_RotZ(float Angulo)
{
	return _RotZ( Angulo);
}
float **DriverMatrix::Cpp_Trans(float X,float Y,float Z)
{
	return _Trans( X, Y, Z);
}
float  *DriverMatrix::CppExtraiParametros(float **MatrizTransformacao)
{
	return ExtraiParametros( MatrizTransformacao);
}



void  DriverMatrix::CppImprimirMatriz(float **Matriz, int NumeroLinhas, int NumeroColunas){
	/*
	initscr();
	int i,j;
	for(i=0;i<NumeroLinhas;i++){
		for(j=0;j<NumeroColunas;j++){
			refresh();
			move(i,j);
			refresh();
			printf("%f",Matriz[i][j]);

		}
	}
	refresh();
	getch();
	endwin();*/
	int i,j;
	for(i=0;i<NumeroLinhas;i++){
		for(j=0;j<NumeroColunas;j++){
			printf("%f\t",Matriz[i][j]);
		}
		printf("\n");
	}
}

/**
 * Starts all the attributes of
 * the Driver
 */

void DriverMatrix::initAttributes ( )
{


}



}
